/**
 * Notes: 项目分支数据模型
 * Ver : CCMiniCloud Framework 2.0.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2023-08-30 19:20:00
 */

const BaseModel = require('../../../framework/platform/model/base_model.js');
const util = require('../../../framework/helpers/util.js');
const dataUtil = require('../../../framework/helpers/data_util.js');
const timeUtil = require('../../../framework/helpers/time_util.js');

class ProjectBranchModel extends BaseModel {

	/** 构造函数 */
	constructor() {
		super();
		
		// 设置集合名
		this.setCollectionName('project_branches');
		
		// 字段定义
		this.DB_STRUCTURE = {
			_pid: 'string|true',        // 项目ID (系统保留，不修改)
			
			// 基础信息
			projectId: 'string|true',    // 关联的项目ID
			name: 'string|true',         // 分支名称
			parentId: 'string|false',    // 父分支ID
			isMaster: 'boolean|true|default=false',  // 是否主分支
			isActive: 'boolean|true|default=true',   // 是否活动分支
			
			// 源节点信息
			sourceNodeId: 'string|false',    // 源节点ID
			sourceNodeTime: 'int|false',     // 源节点时间戳
			
			// 分支特有字段
			// 状态字段
			level1: 'int|true|default=1',     // 一级状态
			level2: 'string|true|default=director', // 二级状态
			level3: 'string|false',           // 三级状态
			level4: 'string|false',           // 四级状态
			statusDesc: 'string|true',        // 状态描述
			completionPercentage: 'int|true|default=0', // 分支完成度
			
			// 时间信息
			createTime: 'int|true',     // 创建时间
			updateTime: 'int|true',     // 更新时间
			stateTime: 'int|true',      // 状态更新时间
			
			// 创建者信息
			createdBy: 'string|true',   // 创建者ID
			createdByName: 'string|true' // 创建者姓名
		};
	}

	// 静态集合名称
	static get CL() {
		return this.C('project_branches');
	}
	
	/**
	 * 获取项目的所有分支
	 * @param {String} projectId 项目ID
	 * @returns {Promise<Array>} 分支列表
	 */
	static async getBranchesForProject(projectId) {
		const query = {
			projectId: projectId
		};
		
		const orderBy = {
			'createTime': 'asc'
		};
		
		try {
			return await this.getAll(query, '*', orderBy);
		} catch (err) {
			console.error('[getBranchesForProject] 获取项目分支失败:', err);
			throw err;
		}
	}
	
	/**
	 * 获取项目的主分支
	 * @param {String} projectId 项目ID
	 * @returns {Promise<Object>} 主分支信息
	 */
	static async getMasterBranch(projectId) {
		const query = {
			projectId: projectId,
			isMaster: true
		};
		
		try {
			return await this.getOne(query);
		} catch (err) {
			console.error('[getMasterBranch] 获取主分支失败:', err);
			throw err;
		}
	}
	
	/**
	 * 获取批量项目的主分支列表
	 * @param {Array} projectIds 项目ID数组
	 * @returns {Promise<Array>} 主分支列表
	 */
	static async getMasterBranches(projectIds) {
		if (!Array.isArray(projectIds) || projectIds.length === 0) {
			return [];
		}
		
		const query = {
			projectId: {
				$in: projectIds
			},
			isMaster: true
		};
		
		try {
			return await this.getAll(query);
		} catch (err) {
			console.error('[getMasterBranches] 批量获取主分支失败:', err);
			throw err;
		}
	}
	
	/**
	 * 创建分支
	 * @param {Object} data 分支数据
	 * @returns {Promise<String>} 创建的分支ID
	 */
	async createBranch(data) {
		try {
			console.log('[createBranch] 开始创建分支:', JSON.stringify(data, null, 2));
			
			// 确保必填字段
			if (!data.projectId) {
				throw new Error('缺少projectId');
			}
			
			if (!data.name) {
				throw new Error('缺少分支名称');
			}
			
			// 设置时间戳
			const now = Math.floor(Date.now() / 1000);
			
			if (!data.createTime) data.createTime = now;
			if (!data.updateTime) data.updateTime = now;
			if (!data.stateTime) data.stateTime = now;
			
			// 处理_pid字段
			data._pid = this.PID;
			
			const id = await this.add(data);
			console.log('[createBranch] 分支创建成功，ID:', id);
			
			// 如果是主分支，更新项目的masterBranchId
			if (data.isMaster) {
				// 导入ProjectModel
				const ProjectModel = require('./project_model.js');
				const projectModel = new ProjectModel();
				
				await projectModel.edit({
					_id: data.projectId
				}, {
					masterBranchId: id
				});
				console.log('[createBranch] 已更新项目主分支ID');
			}
			
			return id;
		} catch (err) {
			console.error('[createBranch] 创建分支失败:', err.message || err);
			throw err;
		}
	}
	
	/**
	 * 获取分支详情
	 * @param {String} id 分支ID
	 * @returns {Promise<Object>} 分支详情
	 */
	async getBranchById(id) {
		try {
			return await this.getOne({ _id: id });
		} catch (err) {
			console.error('[getBranchById] 获取分支详情失败:', err);
			throw err;
		}
	}
	
	/**
	 * 更新分支信息
	 * @param {String} id 分支ID
	 * @param {Object} data 要更新的数据
	 * @returns {Promise<Boolean>} 更新结果
	 */
	async updateBranch(id, data) {
		try {
			console.log('[updateBranch] 更新分支:', id, JSON.stringify(data, null, 2));
			
			// 更新修改时间
			data.updateTime = Math.floor(Date.now() / 1000);
			
			// 如果更新了状态，更新状态时间
			if (data.level1 !== undefined || 
				data.level2 !== undefined || 
				data.level3 !== undefined || 
				data.level4 !== undefined) {
				data.stateTime = data.updateTime;
			}
			
			const result = await this.edit({ _id: id }, data);
			console.log('[updateBranch] 分支更新成功');
			return result;
		} catch (err) {
			console.error('[updateBranch] 更新分支失败:', err.message || err);
			throw err;
		}
	}
	
	/**
	 * 设置分支为主分支
	 * @param {String} branchId 分支ID
	 * @returns {Promise<Boolean>} 操作结果
	 */
	async setAsMaster(branchId) {
		try {
			// 获取分支信息
			const branch = await this.getOne({ _id: branchId });
			if (!branch) {
				throw new Error('分支不存在');
			}
			
			// 将同项目的其他分支设为非主分支
			await this.edit({
				projectId: branch.projectId,
				isMaster: true
			}, {
				isMaster: false
			});
			
			// 设置当前分支为主分支
			await this.edit({ _id: branchId }, { isMaster: true });
			
			// 更新项目的masterBranchId
			const ProjectModel = require('./project_model.js');
			const projectModel = new ProjectModel();
			
			await projectModel.edit({
				_id: branch.projectId
			}, {
				masterBranchId: branchId
			});
			
			console.log('[setAsMaster] 主分支设置成功');
			return true;
		} catch (err) {
			console.error('[setAsMaster] 设置主分支失败:', err.message || err);
			throw err;
		}
	}
	
	/**
	 * 构建分支树
	 * @param {Array} branches 分支列表
	 * @returns {Object} 分支树
	 */
	static buildBranchTree(branches) {
		if (!Array.isArray(branches) || branches.length === 0) {
			return {};
		}
		
		try {
			const map = {};
			const tree = {};
			
			// 将所有分支添加到映射表中
			branches.forEach(branch => {
				map[branch._id] = {
					...branch,
					children: []
				};
			});
			
			// 构建树形结构
			branches.forEach(branch => {
				if (branch.parentId && map[branch.parentId]) {
					// 如果有父分支，添加到父分支的children中
					map[branch.parentId].children.push(map[branch._id]);
				} else {
					// 如果没有父分支，作为根节点
					tree[branch._id] = map[branch._id];
				}
			});
			
			return tree;
		} catch (err) {
			console.error('[buildBranchTree] 构建分支树失败:', err);
			return {};
		}
	}
}

module.exports = ProjectBranchModel; 